package org.jeecg.common.util;

import io.minio.*;
import io.minio.errors.MinioException;
import io.minio.http.Method;
import lombok.extern.slf4j.Slf4j;
import org.jeecg.common.constant.SymbolConstant;
import org.jeecg.common.util.filter.SsrfFileTypeFilter;
import org.jeecg.common.util.filter.StrAttackFilter;
import org.springframework.web.multipart.MultipartFile;

import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.URLDecoder;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import java.text.SimpleDateFormat;
import java.util.Date;

/**
 * minio文件上传工具类
 * @author: jeecg-boot
 */
@Slf4j
public class MinioUtil {
    private static String minioUrl;
    private static String minioName;
    private static String minioPass;
    private static String bucketName;

    public static void setMinioUrl(String minioUrl) {
        MinioUtil.minioUrl = minioUrl;
    }

    public static void setMinioName(String minioName) {
        MinioUtil.minioName = minioName;
    }

    public static void setMinioPass(String minioPass) {
        MinioUtil.minioPass = minioPass;
    }

    public static void setBucketName(String bucketName) {
        MinioUtil.bucketName = bucketName;
    }

    public static String getMinioUrl() {
        return minioUrl;
    }

    public static String getBucketName() {
        return bucketName;
    }

    private static MinioClient minioClient;

    /**
     * 根据文件名或路径判断文件类型是图像还是普通文件。
     *
     * @param filePathOrName 文件的完整路径或仅文件名
     * @return "image" 如果是图像文件，否则返回 "file"
     */
    private static String determineFileType(String filePathOrName) {
        int lastDotIndex = filePathOrName.lastIndexOf('.');
        if (lastDotIndex > 0 && lastDotIndex < filePathOrName.length() - 1) {
            String extension = filePathOrName.substring(lastDotIndex + 1).toLowerCase();
            switch (extension) {
                case "jpg":
                case "jpeg":
                case "png":
                case "gif":
                case "bmp":
                    return "image"; // 图像类型
                default:
                    return "file"; // 非图像类型
            }
        }
        return "file"; // 如果没有扩展名或扩展名不匹配，认为是非图像类型
    }



    /**
     * 上传文件
     * @param file
     * @return
     */
    public static String upload(MultipartFile file, String bizPath, String customBucket) throws Exception {
        String fileUrl = "";
        //update-begin-author:wangshuai date:20201012 for: 过滤上传文件夹名特殊字符，防止攻击
        bizPath = StrAttackFilter.filter(bizPath);
        //update-end-author:wangshuai date:20201012 for: 过滤上传文件夹名特殊字符，防止攻击

        //update-begin-author:liusq date:20210809 for: 过滤上传文件类型
        SsrfFileTypeFilter.checkUploadFileType(file);
        //update-end-author:liusq date:20210809 for: 过滤上传文件类型

        String newBucket = bucketName;
        if(oConvertUtils.isNotEmpty(customBucket)){
            newBucket = customBucket;
        }
        try {
            initMinio(minioUrl, minioName,minioPass);
            // 检查存储桶是否已经存在
            if(minioClient.bucketExists(BucketExistsArgs.builder().bucket(newBucket).build())) {
                log.info("Bucket already exists.");
            } else {
                // 创建一个名为ota的存储桶
                minioClient.makeBucket(MakeBucketArgs.builder().bucket(newBucket).build());
                log.info("create a new bucket.");
            }
            InputStream stream = file.getInputStream();
            // 获取文件名
            String orgName = file.getOriginalFilename();
            if("".equals(orgName)){
                orgName=file.getName();
            }
            orgName = CommonUtils.getFileName(orgName);
            String objectName = bizPath+"/"
                                +( orgName.indexOf(".")==-1
                                   ?orgName + "_" + System.currentTimeMillis()
                                   :orgName.substring(0, orgName.lastIndexOf(".")) + "_" + System.currentTimeMillis() + orgName.substring(orgName.lastIndexOf("."))
                                 );

            // 使用putObject上传一个本地文件到存储桶中。
            if(objectName.startsWith(SymbolConstant.SINGLE_SLASH)){
                objectName = objectName.substring(1);
            }
            PutObjectArgs objectArgs = PutObjectArgs.builder().object(objectName)
                    .bucket(newBucket)
                    .contentType("application/octet-stream")
                    .stream(stream,stream.available(),-1).build();
            minioClient.putObject(objectArgs);
            stream.close();
            fileUrl = minioUrl+newBucket+"/"+objectName;
        }catch (Exception e){
            log.error(e.getMessage(), e);
        }
        return fileUrl;
    }

//    /**
//     * 上传文件
//     * @param file 文件
//     *  @param customBucket 自定义bucket
//     * @return
//     */
//    public static String upload(MultipartFile file,String customBucket) throws Exception {
//        String fileUrl = "";
//        // 获取文件名
//        String orgName = file.getOriginalFilename();
//        if ("".equals(orgName)) {
//            orgName = file.getName();
//        }
//        orgName = CommonUtils.getFileName(orgName);
//        String bizPath= determineFileType(orgName);
//        String contentType = guessContentTypeFromName(orgName);
//        //update-begin-author:wangshuai date:20201012 for: 过滤上传文件夹名特殊字符，防止攻击
//        bizPath = StrAttackFilter.filter(bizPath);   //bizPath   可以理解到底是file 还是image    等等
//        //update-end-author:wangshuai date:20201012 for: 过滤上传文件夹名特殊字符，防止攻击
//
//        //update-begin-author:liusq date:20210809 for: 过滤上传文件类型
//        SsrfFileTypeFilter.checkUploadFileType(file);
//        //update-end-author:liusq date:20210809 for: 过滤上传文件类型
//
//        String newBucket = bucketName;
////        if(oConvertUtils.isNotEmpty(customBucket)){
////            newBucket = customBucket;
////        }
//        try {
//            initMinio(minioUrl, minioName,minioPass);
////            // 检查存储桶是否已经存在
////            if(minioClient.bucketExists(BucketExistsArgs.builder().bucket(newBucket).build())) {
////                log.info("Bucket already exists.");
////            } else {
////                // 创建一个名为ota的存储桶
////                minioClient.makeBucket(MakeBucketArgs.builder().bucket(newBucket).build());
////                log.info("create a new bucket.");
////            }
//            InputStream stream = file.getInputStream();
//
//            String fileName = System.currentTimeMillis() + "-" + orgName;
//            String objectName = bizPath + "/" + DateTimeUtils.getFormatDate(new Date(), DateTimeUtils.PARTDATEFORMAT) + "/" + fileName;
//            System.out.println("objectName = " + objectName);
//
//            // 使用putObject上传一个本地文件到存储桶中。
//            if(objectName.startsWith(SymbolConstant.SINGLE_SLASH)){
//                objectName = objectName.substring(1);
//            }
//            PutObjectArgs objectArgs = PutObjectArgs.builder().object(objectName)
//                    .bucket(newBucket)
//                    .contentType(contentType)
//                    .stream(stream,stream.available(),-1).build();
//            minioClient.putObject(objectArgs);
//            stream.close();
//            fileUrl = minioUrl+newBucket+"/"+objectName;
//        }catch (Exception e){
//            log.error(e.getMessage(), e);
//        }
//        return fileUrl;
//    }

    /**
     * 上传文件到MinIO，增强路径配置校验
     *
     * @param file         待上传文件
     * @param customBucket 自定义存储桶（可选）
     * @return 文件访问URL，若失败返回空字符串
     * @throws Exception 抛出非MinIO客户端的异常（如文件处理异常）
     */
    public static String upload(MultipartFile file, String customBucket) throws Exception {
        // 1. 校验MinIO核心配置是否存在（排查配置缺失导致的路径错误）
        validateMinioConfig();

        String fileUrl = "";
        String orgName = getOriginalFileName(file);
        if (orgName == null || orgName.isEmpty()) {
            log.error("上传文件名称为空，无法处理");
            return fileUrl;
        }

        // 2. 处理文件路径相关参数（增强日志，便于追踪路径拼接）
        orgName = CommonUtils.getFileName(orgName); // 清理原始文件名
        String bizPath = determineFileType(orgName); // 确定文件类型目录（如image、file）
        bizPath = StrAttackFilter.filter(bizPath); // 过滤特殊字符
        log.debug("文件类型目录(bizPath)：{}", bizPath);

        String contentType = guessContentTypeFromName(orgName);
        log.debug("文件MIME类型：{}", contentType);

        // 3. 确定存储桶（优先使用自定义，否则用默认）
        String newBucket = resolveBucket(customBucket);
        log.info("当前使用的存储桶：{}", newBucket);

        try (InputStream stream = file.getInputStream()) { // 自动关闭流，避免资源泄漏
            // 4. 生成对象存储路径（精确日志输出每一步拼接）
            String fileName = System.currentTimeMillis() + "-" + orgName;
            String dateDir = new SimpleDateFormat(DateTimeUtils.PARTDATEFORMAT).format(new Date());
            String objectName = bizPath + "/" + dateDir + "/" + fileName;
            // 处理可能的开头斜杠问题
            if (objectName.startsWith("/")) {
                objectName = objectName.substring(1);
            }
            log.info("MinIO对象存储路径(objectName)：{}", objectName);

            // 5. 初始化MinIO客户端（确保客户端初始化正确）
            initMinio(minioUrl, minioName, minioPass);
            log.info("MinIO客户端初始化完成，服务端地址：{}", minioUrl);

            // 6. 检查并创建存储桶（验证存储桶可用性）
            checkAndCreateBucket(newBucket);

            // 7. 执行上传（核心步骤，精确捕获MinIO相关异常）
            PutObjectArgs objectArgs = PutObjectArgs.builder()
                    .object(objectName)
                    .bucket(newBucket)
                    .contentType(contentType)
                    .stream(stream, stream.available(), -1)
                    .build();
            minioClient.putObject(objectArgs);
            log.info("文件上传成功，对象路径：{}/{}", newBucket, objectName);

            // 8. 生成访问URL（重点校验路径拼接格式）
            fileUrl = buildFileUrl(minioUrl, newBucket, objectName);
            log.info("生成的文件访问URL：{}", fileUrl);

        } catch (MinioException e) {
            // 捕获MinIO客户端异常（路径错误常在此类异常中体现）
            log.error("MinIO客户端异常 - 错误代码：{}，消息：{}", e.getCause(), e.getMessage(), e);
        } catch (InvalidKeyException | NoSuchAlgorithmException e) {
            log.error("MinIO密钥或算法异常（可能是配置错误）：{}", e.getMessage(), e);
        } catch (IOException e) {
            log.error("文件流处理异常：{}", e.getMessage(), e);
        }

        return fileUrl;
    }

    /**
     * 解析最终使用的存储桶
     */
    private static String resolveBucket(String customBucket) {
        if (customBucket != null && !customBucket.trim().isEmpty()) {
            return customBucket.trim();
        }
        return bucketName;
    }

    /**
     * 检查存储桶是否存在，不存在则创建
     */
    private static void checkAndCreateBucket(String bucket) throws Exception {
        if (minioClient.bucketExists(BucketExistsArgs.builder().bucket(bucket).build())) {
            log.debug("存储桶已存在：{}", bucket);
        } else {
            minioClient.makeBucket(MakeBucketArgs.builder().bucket(bucket).build());
            log.info("存储桶不存在，已创建：{}", bucket);
        }
    }

    /**
     * 构建文件访问URL（重点处理URL拼接格式）
     * 解决minioUrl是否带斜杠导致的路径错误
     */
    private static String buildFileUrl(String minioUrl, String bucket, String objectName) {
        // 确保minioUrl末尾不带斜杠，避免出现//
        String baseUrl = minioUrl.trim();
        if (baseUrl.endsWith("/")) {
            baseUrl = baseUrl.substring(0, baseUrl.length() - 1);
        }
        // 拼接URL（格式：baseUrl/bucket/objectName）
        return baseUrl + "/" + bucket + "/" + objectName;
    }

    /**
     * 获取文件原始名称（兼容不同场景）
     */
    private static String getOriginalFileName(MultipartFile file) {
        String orgName = file.getOriginalFilename();
        if (orgName == null || orgName.trim().isEmpty()) {
            orgName = file.getName();
        }
        return orgName;
    }


    /**
     * 校验MinIO核心配置是否存在
     * （配置缺失是路径错误的常见原因）
     */
    private static void validateMinioConfig() {
        if (minioUrl == null || minioUrl.trim().isEmpty()) {
            log.error("MinIO配置错误：minioUrl为空，请检查配置");
            throw new IllegalArgumentException("MinIO服务地址未配置");
        }
        if (minioName == null || minioName.trim().isEmpty()) {
            log.error("MinIO配置错误：minioName（访问密钥）为空，请检查配置");
            throw new IllegalArgumentException("MinIO访问密钥未配置");
        }
        if (minioPass == null || minioPass.trim().isEmpty()) {
            log.error("MinIO配置错误：minioPass（密钥）为空，请检查配置");
            throw new IllegalArgumentException("MinIO密钥未配置");
        }
        if (bucketName == null || bucketName.trim().isEmpty()) {
            log.error("MinIO配置错误：默认bucketName为空，请检查配置");
            throw new IllegalArgumentException("MinIO默认存储桶未配置");
        }
        log.debug("MinIO核心配置校验通过，服务地址：{}，默认存储桶：{}", minioUrl, bucketName);
    }


    // 辅助函数用于猜测contentType
    private static String guessContentTypeFromName(String name) {
        int lastDotIndex = name.lastIndexOf('.');
        if (lastDotIndex > 0 && lastDotIndex < name.length() - 1) {
            String extension = name.substring(lastDotIndex + 1).toLowerCase();
            switch (extension) {
                case "pdf":
                    return "application/pdf";
                case "jpg":
                case "jpeg":
                    return "image/jpeg";
                case "png":
                    return "image/png";
                case "gif":
                    return "image/gif";
                case "bmp":
                    return "image/bmp";
                case "doc":
                case "docx":
                    return "application/msword";
                case "xls":
                case "xlsx":
                    return "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet";
                // 其他文件类型可以继续添加...
                default:
                    return "application/octet-stream"; // 默认值，用于未知文件类型
            }
        }
        return "application/octet-stream"; // 如果没有扩展名，也使用默认值
    }

//    /**
//     * 文件上传
//     * @param file
//     * @param bizPath
//     * @return
//     */
//    public static String upload(MultipartFile file, String bizPath) throws Exception {
//        return upload(file,bizPath,null);
//    }

    /**
     * 获取文件流
     * @param bucketName
     * @param objectName
     * @return
     */
    public static InputStream getMinioFile(String bucketName,String objectName){
        InputStream inputStream = null;
        try {
            initMinio(minioUrl, minioName, minioPass);
            GetObjectArgs objectArgs = GetObjectArgs.builder().object(objectName)
                    .bucket(bucketName).build();
            inputStream = minioClient.getObject(objectArgs);
        } catch (Exception e) {
            log.info("文件获取失败" + e.getMessage());
        }
        return inputStream;
    }

    /**
     * 删除文件
     * @param bucketName
     * @param objectName
     * @throws Exception
     */
    public static void removeObject(String bucketName, String objectName) {
        try {
            initMinio(minioUrl, minioName,minioPass);
            RemoveObjectArgs objectArgs = RemoveObjectArgs.builder().object(objectName)
                    .bucket(bucketName).build();
            minioClient.removeObject(objectArgs);
        }catch (Exception e){
            log.info("文件删除失败" + e.getMessage());
        }
    }

    /**
     * 获取文件外链
     * @param bucketName
     * @param objectName
     * @param expires
     * @return
     */
    public static String getObjectUrl(String bucketName, String objectName, Integer expires) {
        initMinio(minioUrl, minioName,minioPass);
        try{
            //update-begin---author:liusq  Date:20220121  for：获取文件外链报错提示method不能为空，导致文件下载和预览失败----
            GetPresignedObjectUrlArgs objectArgs = GetPresignedObjectUrlArgs.builder().object(objectName)
                    .bucket(bucketName)
                    .expiry(expires).method(Method.GET).build();
            //update-begin---author:liusq  Date:20220121  for：获取文件外链报错提示method不能为空，导致文件下载和预览失败----
            String url = minioClient.getPresignedObjectUrl(objectArgs);
            return URLDecoder.decode(url,"UTF-8");
        }catch (Exception e){
            log.info("文件路径获取失败" + e.getMessage());
        }
        return null;
    }

    /**
     * 初始化客户端
     * @param minioUrl
     * @param minioName
     * @param minioPass
     * @return
     */
    private static MinioClient initMinio(String minioUrl, String minioName,String minioPass) {
        if (minioClient == null) {
            try {
                minioClient = MinioClient.builder()
                        .endpoint(minioUrl)
                        .credentials(minioName, minioPass)
                        .build();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return minioClient;
    }

    /**
     * 上传文件到minio
     * @param stream
     * @param relativePath
     * @return
     */
    public static String upload(InputStream stream,String relativePath) throws Exception {
        initMinio(minioUrl, minioName,minioPass);
        if(minioClient.bucketExists(BucketExistsArgs.builder().bucket(bucketName).build())) {
            log.info("Bucket already exists.");
        } else {
            // 创建一个名为ota的存储桶
            minioClient.makeBucket(MakeBucketArgs.builder().bucket(bucketName).build());
            log.info("create a new bucket.");
        }
        PutObjectArgs objectArgs = PutObjectArgs.builder().object(relativePath)
                .bucket(bucketName)
                .contentType("application/octet-stream")
                .stream(stream,stream.available(),-1).build();
        minioClient.putObject(objectArgs);
        stream.close();
        return minioUrl+bucketName+"/"+relativePath;
    }


    public static String uploadByte(byte[] fileData, String fileName, String bizPath, String customBucket) throws Exception {
        String fileUrl = "";
        // 过滤上传文件夹名特殊字符，防止攻击
        bizPath = StrAttackFilter.filter(bizPath);

        // 过滤上传文件类型（需要根据字节数组实现文件类型检查）
        String contentType = guessContentTypeFromName(fileName);

        String newBucket = bucketName;
        if(oConvertUtils.isNotEmpty(customBucket)){
            newBucket = customBucket;
        }
        try {
            initMinio(minioUrl, minioName, minioPass);
            // 检查存储桶是否已经存在
            if(minioClient.bucketExists(BucketExistsArgs.builder().bucket(newBucket).build())) {
                log.info("Bucket already exists.");
            } else {
                // 创建一个名为ota的存储桶
                minioClient.makeBucket(MakeBucketArgs.builder().bucket(newBucket).build());
                log.info("create a new bucket.");
            }

            // 获取文件名
            String orgName = CommonUtils.getFileName(fileName);
            String objectName = bizPath + "/" +
                    (orgName.indexOf(".") == -1
                            ? orgName + "_" + System.currentTimeMillis()
                            : orgName.substring(0, orgName.lastIndexOf(".")) + "_" + System.currentTimeMillis() + orgName.substring(orgName.lastIndexOf("."))
                    );

            // 使用putObject上传一个本地文件到存储桶中。
            if(objectName.startsWith(SymbolConstant.SINGLE_SLASH)){
                objectName = objectName.substring(1);
            }

            ByteArrayInputStream stream = new ByteArrayInputStream(fileData);
            PutObjectArgs objectArgs = PutObjectArgs.builder().object(objectName)
                    .bucket(newBucket)
                    .contentType("contentType")
                    .stream(stream, fileData.length, -1).build();
            minioClient.putObject(objectArgs);
            stream.close();
            fileUrl = minioUrl + newBucket + "/" + objectName;
        } catch (Exception e) {
            log.error(e.getMessage(), e);
            throw e; // 可选：重新抛出异常，让调用者处理
        }
        return fileUrl;
    }


}
